# 作业
# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
# 4、写函数,接收两个数字参数,返回较大的那个数字
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
# 15、编写函数，求1+2+3+…N的和
# 16、编写一个函数，求多个数中的最大值
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
# 18、写一个函数，求多个数的平均值
# 19、写一个自己的len函数，统计指定序列中元素的个数
# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身
# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
# 24、定义函数 generateNum( )
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
# 27、写函数，检查传入字典的每一个value长度，如果大于2，
# 那么仅保留前两个长度的内容， 并将新内容返回给调用者
#  28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
# 29、编写自定义函数，完成一个简单的减法运算函数
# 30、编写自定义函数，可以输出自己的名字即可。
# 31、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
# 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
# 1 代表剪刀 2 代表石头 3 代表布
# 32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
# 33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
# 34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
# 35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
# 36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
# 37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
# 举例：
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# 返回：[454]
#  38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市


"""
1、写函数, 将传入的列表或元祖对象的奇数位索引对应的元素
"""
def a (lst):
    result=[]
    for i in range(len(lst)):
        if i%2!=0:
            result.append(lst[i])
print(a([1, 2, 3, 4, 5]))
"""
2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
"""
# def a (b):
#     if isinstance(b,str):
#         if len(b)>5:
#             print(f'传入的字符串：{b}，长度大于5')
#         else:
#             print(print(f'传入的字符串：{b}，长度小于5'))
#     if isinstance(b, list):
#         if len(b) > 5:
#             print(f'传入的列表：{b}，长度大于5')
#         else:
#             print(f'传入的列表：{b}，长度大于5')
#     if isinstance(b,tuple):
#         if len(b)>5:
#             print(f'传入的元祖：{b}，长度大于5')
#         else:
#             print(f'传入的元祖：{b}，长度小于5')

def a (b):
    if isinstance(b,str):
        if len(b)>5:
            print(f"输入的字符:{b}大于5")
        else:
            print(f"输入的字符：{b}小于5")
    if isinstance(b,list):
        if len(b)>5:
            print(f"输入的列表:{b}大于5")
        else:
            print(f"输入的列表:{b}大于5")
    if isinstance(b,tuple):
        if len(b)>5:
            print(print(f"输入的列表:{b}大于5"))



"""
3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
"""
# def a (n:str):
#     shuzi=0
#     zimu=0
#     konge=0
#     qita=0
#     for i in n:
#         if i in "0123456789":
#             shuzi+=1
#         if i >="a"and i<="z"or i>="A"and i<="Z":
#             zimu+=1
#         if i in " ":
#             konge+=1
#         else:
#             qita+=1
#     return f"空格的个数为：{konge}，字母的个数为：{zimu}，数字的个数为：{shuzi}，其他字符的个数为：{qita}"
# print(a("asd   123 !@#$%^&*("))
#     return f"空格的个数为：{konge}，字母的个数为：{zimu}，数字的个数为：{shuzi}，其他字符的个数为：{qitazifu}"
"""
4、写函数,接收两个数字参数,返回较大的那个数字
"""
# def a (c,d):
#     if c>d:
#         return c
#     if c<d:
#         return d
#     if c==d:
#         return ("两个数相等")
# print(a(4,5))

"""
5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
"""
# def calculate(*args):
#     return args
#
# print(calculate(5, 10, 15, 20))

"""
6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
"""
# def a (b:str):
#     daxie=0
#     xiaoxie=0
#     for i in b:
#         if i <="a"and i>="z":
#             daxie+=1
#         if i<="A"and i>="Z":
#             xiaoxie+=1
#     return daxie,xiaoxie

"""
# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标def new_list(list_obj:list,k:int)->list:
    if len(list_obj) == 30:
        k1 = list_obj[:k][::-1]
        k2 = list_obj[k:][::-1]
        return k1+k2
    else: # 长度不够30或者是超过30
        return []
"""

"""
9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
"""
# def a (name, age, address, gender="男"):
#     print(f"姓名: {name}")
#     print(f"性别: {gender}")
#     print(f"年龄: {age}")
#     print(f"地址: {address}")
# print(a("张三",25,"南方"))

"""
10、写函数,接收n个数字,返回这些数字的和(动态传参)
"""
# def a (b):
#     sum = 0
#     for i in b:
#         sum+=1
#     return sum

"""
11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
"""
# def a (*args,**kwargs):
#     print(args)
#     print(kwargs)
"""
12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
"""
# def a (lst):
#     return "_".join(lst)
# n = a(["1","2"])
# print(n)

"""
# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
"""
# def a(n):
#     b = 1
#     for i in range(1,n+1):
#         b*=i
#     return b
# print(a(100))
"""
# # 15、编写函数，求1+2+3+…N的和
"""
# def a (n):
#     b = 0
#     for i in range(1,n+1):
#         b+=i
#     return b
# print(a(500))

"""
16、编写一个函数，求多个数中的最大值
"""
# 多个数值加*
# def a (*b):
#     a = b[0]
#     for i in b:
#         if i > a:
#             a = i
#     return (f"最大值为{a}")
# print(a(11, 22, 33, 44, 111))



"""
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
"""
# def a (*b):
#     str2 = ""
#     for i in b:
#         if (i >= 'a' and i <= 'z') or (i >= 'A' and i <= 'Z'):
#             str2 += i
#     return str2
# print(a('asdasdljklasioAASDASD1234534534000'))
"""
18、写一个函数，求多个数的平均值
"""
# def a (*n):
#     return sum(n)/len(n)
# print(a(5,2,36,9,76,2,2,5))

"""
# 19、写一个自己的len函数，统计指定序列中元素的个数
"""
def a (n):
    b=0
    for i in n:
        b+=1
    return (f"元素的个数为{i}个")


"""
# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
"""
# def a (n):
#     result = []
#     for i in n :
#         if i%2!=0:
#             result.append(a[i])
#     return result

"""
# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身 1000以内有多少个
"""

"""
22、定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
"""
# def a (lst):
#     if len(lst)<100:
#        lst=lst[:100]
#     unique_lst = list(set(lst))
#     unique_lst.sort(reverse=True)
#     return unique_lst
# lst= (1,2,3,6,89,1)
# print(a(lst))

"""
23、定义函数 getLength，打印用户传入的容器类型和数据长度
"""
# def getLength(a):
#     b = type(a)
#     n = len(a)
#     print(f"容器长度是",n)
#     print(f"容器类型是",b)
# print(getLength("hello"))

"""
# 24、定义函数 generateNum( )
"""
def generateNum():
    print("定义函数")
"""
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
"""
# def moreThan(num):
#     if num > 1500:
#         print("数字大于")
#     elif num < 1500:
#         print("数字小于")
#     elif num == 1500:
#         print("数字等于")
#

"""
# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
"""
# def a (b,c):
#     sum = 0
#     for i in range(b,c+1):
#         sum += i ** 2
#     return (f"所有数的平方和是:{sum}")
"""
# 27、写函数，检查传入字典的每一个value长度，如果大于2，
# 那么仅保留前两个长度的内容， 并将新内容返回给调用者
"""

# def a (b):
#     if isinstance(b,(str,list,tuple)):
#         return len(b) == 0
#     else:
#         print("输入内容有误")
# print(a("abc"))
"""
# 29、编写自定义函数，完成一个简单的减法运算函数
"""
# def a (b,c):
#     return b - c
# print(a(5,3))
"""
30、编写自定义函数，可以输出自己的名字即可。
"""

# def a (name):
#     print(f"name")

"""
# 31、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
# 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
# 1 代表剪刀 2 代表石头 3 代表布
"""
"""
# 32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
"""
# def a (s):
#     return s[::-1]
"""
# # 33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
"""
# def a (b):
#     result = []
#     for i in b:
#         if i%2==0:
#             result.append(i)
#     return result

"""
# 34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
"""
# def a (b):
#     i = b[0]
#     for i in b:
#         if len(i)>len(b):
#             b = i
#     return (f"最长的字符串{b}")
# print(a(["apple", "banana", "pear", "strawberry", "kiwi"]))
"""
# 35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
"""
# def a (b):
#     sum = 0
#     for i in b:
#         sum+=i**2
#     return f"所有平方数的和是:{sum}"
"""
# 36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
"""
def a (b):
    def d_str(str1: str) -> str:  # asdb asd asd qwe
        ne_str = ""
        str_list = str1.split(' ')
        for i in str_list:
            ne_str += i.capitalize() + " "
        return ne_str
"""
# 37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
"""
# 举例：
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# 返回：[454]
"""
# 38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市
"""
# def enroll (name, gender, age, city):
#     print(f"姓名: {name}")
#     print(f"性别: {gender}")
#     print(f"年龄: {age}")
#     print(f"城市: {city}")
# print("张三","男",25,"南方")
